package com.softer.chengxin.score.service.impl;

import com.softer.chengxin.common.domin.Common;
import com.softer.chengxin.common.enums.NumberEnum;
import com.softer.chengxin.common.util.DateFormatUtil;
import com.softer.chengxin.score.dao.NewTypeDao;
import com.softer.chengxin.score.dao.SDManagerDao;
import com.softer.chengxin.score.entity.ScoreDetailVO;
import com.softer.chengxin.score.service.NewTypeService;
import com.softer.chengxin.score.util.ScoreUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * @author Gong Zhiyang
 * @date 2019/2/15
 */
@Service
public class NewTypeServiceImpl implements NewTypeService {
    @Autowired
    private SDManagerDao managerDao;
    @Autowired
    private NewTypeDao newTypeDao;
    @Autowired
    private ScoreUtil scoreUtil;

    private static final String EFFECT_BEGIN_TIME = "2019-3-25";
    private static final String EFFECT_END_TIME = "2019-3-31";
    private static final String PUBLIC_BEGIN_TIME = "2019-1-1";
    private static final Integer SEVEN = 7;

    /**
     * 新增优良负面类型
     *
     * @return 结果
     */
    @Override
    public void addScore() {
        List<Integer> result = new ArrayList<>();
        List<Integer> corpList = newTypeDao.getCorpList();
        for (Integer id : corpList) {
//            boolean flag = checkPerson(id);
            boolean flag = recheck(id);
            if (flag) {
                result.add(id);
            } else {
                continue;
            }
        }
        addNewTypeScore(result);
    }

    @Override
    public void updateScore() {
        //获取主管部门定义的年份
        String year = DateFormatUtil.getSysYear();
        //第一步，查询所有需要更新分数的企业
        List<Integer> list = newTypeDao.getAllCorpId(year);
        //第二步，重新计算企业的分数
        for (Integer id : list) {
            scoreUtil.updateRecord(id);
        }

    }

    /**
     * 手动调用
     * 更新所有企业分数
     */
    @Override
    public void updateCorpScore() {
        List<Integer> corpList = newTypeDao.getCoreIdList();
        for (Integer id : corpList) {
            scoreUtil.updateRecord(id);
        }
    }

    /**
     * 添加需要加分的企业，并重新计算分数
     *
     * @param result 需要加分的企业ID集合
     */
    private void addNewTypeScore(List<Integer> result) {
        //参加项目经理培训比例100%，并增加一条优良加分记录
        ScoreDetailVO organizationScoreDetailVO = new ScoreDetailVO();
        organizationScoreDetailVO.setAdder(Common.ADMIN);
        organizationScoreDetailVO.setReason("参加项目经理培训比例100%");
        organizationScoreDetailVO.setScoreTypeId(SEVEN);
        organizationScoreDetailVO.setEffectiveBeginTime(EFFECT_BEGIN_TIME);
        organizationScoreDetailVO.setEffectiveEndTime(EFFECT_END_TIME);
        organizationScoreDetailVO.setState(SEVEN);
        organizationScoreDetailVO.setProjectId(Common.ZERO);
        organizationScoreDetailVO.setScore(new BigDecimal(NumberEnum.ONE.getNum()));
        organizationScoreDetailVO.setInfoType(NumberEnum.ONE.getNum());
        organizationScoreDetailVO.setPublicityBeginTime(PUBLIC_BEGIN_TIME);

        for (Integer corpId : result) {
            organizationScoreDetailVO.setCorpId(corpId);
            managerDao.addScore(organizationScoreDetailVO);
            scoreUtil.updateRecord(corpId);
        }
    }

    /**
     * 验证企业项目经理是否都参加培训
     *
     * @param id 企业ID
     * @return 验证结果(true都参加, false没有都参加)
     */
    public boolean checkPerson(Integer id) {
        //查询企业所有的项目经理
        List<Integer> personIdList = newTypeDao.getPersonId(id);
        if (personIdList.size() > 0) {
            for (Integer personId : personIdList) {
                boolean check = check(personId, id);
                if (check) {
                    continue;
                } else {
                    //如果企业有，但是培训没有，跳出循环，进入下一个企业
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 查询培训中是否包含该人员
     *
     * @param personId 项目经理ID
     * @param id       企业ID
     * @return 校验结果
     */
    private boolean check(Integer personId, Integer id) {
        //查询所有的培训的项目经理
        List<Integer> trainPersonIdList = newTypeDao.getTrainPersonId(id);
        for (Integer trainPersonId : trainPersonIdList) {
            if (trainPersonId.equals(personId)) {
                return true;
            }
        }
        //培训中不包括该项目经理，返回false
        return false;
    }


    /**
     * 第一步：查询企业有多少审核通过的项目
     * 第二步：查询每个项目是否有项目经理（如果没有项目经理，则不加分）
     * 第三步：查询每个项目是否有项目经理参加项目经理培训
     * 总结：如果有n个审核通过的项目，每个项目都有项目经理，这些项目最少有一个项目经理参加了项目经理培训，则加分
     *
     * @param id 企业ID
     */
    private boolean recheck(Integer id) {
        //第一步：查询企业有多少审核通过的项目
        List<Integer> projectList = newTypeDao.getProjectList(id);
        for (Integer projectId : projectList) {
            //第二步：查询每个项目是否有项目经理（如果没有项目经理，则不加分）
            List<Integer> personIdList = newTypeDao.getPersonIdList(projectId);
            if (personIdList != null && personIdList.size() > 0) {
                //第三步：查询每个项目是否有项目经理参加项目经理培训
                boolean flag = checkPerson(personIdList);
                if (flag) {
                    continue;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
        return true;
    }

    /**
     * 查询项目经理是否参加过项目经理培训
     *
     * @param personIdList 项目经理ID集合
     * @return 判断结果
     */
    private boolean checkPerson(List<Integer> personIdList) {
        for (Integer id : personIdList) {
            Integer trainId = newTypeDao.getTrainId(id);
            if (trainId != null) {
                return true;
            }
        }
        return false;
    }
}
